home *** CD-ROM | disk | FTP | other *** search
/ Champak 45 / Vol 45.iso / games / bubblegu.swf / scripts / frame_2 / DoAction_11.as < prev    next >
Encoding:
Text File  |  2007-04-20  |  44.4 KB  |  1,630 lines
  1. function tweenManager()
  2. {
  3.    var _loc1_ = this;
  4.    _loc1_.playing = false;
  5.    _loc1_.autoStop = false;
  6.    _loc1_.broadcastEvents = false;
  7.    _loc1_.autoOverwrite = true;
  8.    _loc1_.tweenList = new Array();
  9.    _loc1_.ints = new Array();
  10.    _loc1_.lockedTweens = new Object();
  11.    _loc1_.now = 0;
  12.    _loc1_.isPaused = false;
  13.    _loc1_.pausedTime = 0;
  14. }
  15. function checkInvul()
  16. {
  17.    trace("INVULNERABLITLIY STARTED");
  18.    invulLoop += invulLoopTime / 1000;
  19.    home.display.char._alpha = 75;
  20.    home.display.char.brightnessTo(50,0,"easeOutQuad",0);
  21.    if(invulLoop >= invulLimit)
  22.    {
  23.       home.display.char.brightnessTo(0,0.25,"easeOutQuad",0);
  24.       home.display.char._alpha = 100;
  25.       trace("Invulnerability loop cleared");
  26.       invulLoop = 0;
  27.       home.invul = false;
  28.       clearInterval(invul_interval);
  29.    }
  30. }
  31. function buildMap(map)
  32. {
  33.    trace("  Current Map: " + home.currentMap);
  34.    trace("Current Level: " + home.currentLevel);
  35.    home.treadmill = false;
  36.    treadmill_snd.stop("treadmill");
  37.    home.createEmptyMovieClip("display",15);
  38.    home.display._x = orgX;
  39.    home.display._y = orgY;
  40.    var bkgName = "bkg" + home.currentLevel + "_" + home.currentMap;
  41.    home.display.attachMovie(bkgName,"bkg_mc",14);
  42.    mapW = map[0].length;
  43.    mapH = map.length;
  44.    cMap = map;
  45.    var _loc3_ = -1;
  46.    while((_loc3_ = _loc3_ + 1) < mapH)
  47.    {
  48.       var _loc1_ = -1;
  49.       while((_loc1_ = _loc1_ + 1) < mapW)
  50.       {
  51.          if(map[_loc3_][_loc1_] == 5 || map[_loc3_][_loc1_] == 6)
  52.          {
  53.             home.treadmill = true;
  54.          }
  55.          if(home["Level" + currentLevel].levelExit[0] == home.currentMap && _loc3_ == home["Level" + currentLevel].levelExit[2] && _loc1_ == home["Level" + currentLevel].levelExit[1])
  56.          {
  57.             home.display.attachMovie("exit","exit_mc",200);
  58.             if(home.exit)
  59.             {
  60.                home.display.exit_mc.gotoAndStop(2);
  61.             }
  62.             home.display.exit_mc._x = _loc1_ * TILE_W + TILE_W / 2;
  63.             home.display.exit_mc._y = _loc3_ * TILE_H + TILE_H / 2;
  64.             trace("Exit found, placing at coordinates - " + _loc3_ + " " + _loc1_);
  65.          }
  66.          if(map[_loc3_][_loc1_] == 10)
  67.          {
  68.             home.display.attachMovie("spring","spring_mc_" + _loc3_ + "_" + _loc1_,200 + (_loc3_ + _loc1_));
  69.             home.display["spring_mc_" + _loc3_ + "_" + _loc1_]._x = _loc1_ * TILE_W + TILE_W / 2;
  70.             home.display["spring_mc_" + _loc3_ + "_" + _loc1_]._y = _loc3_ * TILE_H + TILE_H / 2;
  71.          }
  72.       }
  73.    }
  74.    enCol = [];
  75.    var ens = home["Level" + home.currentLevel].myEnemies[home.currentMap - 1];
  76.    home.totalEnemy = ens.length;
  77.    var _loc2_ = -1;
  78.    while((_loc2_ = _loc2_ + 1) < home.totalEnemy)
  79.    {
  80.       enCol.push(false);
  81.       home.display.attachMovie("enemy" + home["Level" + home.currentLevel].myEnemies[home.currentMap - 1][_loc2_][3],"enemy" + _loc2_,1500 + _loc2_);
  82.       var namey = "enemy" + _loc2_;
  83.       home.display[namey].id = _loc2_;
  84.       home.display[namey].eType = home["Level" + home.currentLevel].myEnemies[home.currentMap - 1][_loc2_][3];
  85.       home.display[namey].xpos = ens[_loc2_][1] * TILE_W + TILE_W / 2;
  86.       home.display[namey].ypos = ens[_loc2_][2] * TILE_W + TILE_W / 2;
  87.       home.display[namey].orgX = ens[_loc2_][1];
  88.       home.display[namey].orgY = ens[_loc2_][2];
  89.       home.display[namey].speed = ens[_loc2_][0].speed;
  90.       home.display[namey].xMove = ens[_loc2_][0].xMove;
  91.       home.display[namey].yMove = ens[_loc2_][0].yMove;
  92.    }
  93.    if(starting)
  94.    {
  95.       twinkle_snd = new Sound();
  96.       twinkle_snd.atcPlay("twinkle");
  97.       trace("=======  Setting pickup data for the current Level  =======");
  98.       home.itemsGrabbed = 0;
  99.       home.totalPickups = 0;
  100.       _loc3_ = 0;
  101.       while(_loc3_ < home["Level" + home.currentLevel].myPickups.length)
  102.       {
  103.          home["pu_" + (Number(_loc3_) + 1)] = new Array();
  104.          _loc2_ = 0;
  105.          while(_loc2_ < home["Level" + home.currentLevel].myPickups[_loc3_].length)
  106.          {
  107.             home.totalPickups = home.totalPickups + 1;
  108.             var tempy = new Array();
  109.             tempy = home["Level" + home.currentLevel].myPickups[_loc3_][_loc2_];
  110.             home["pu_" + (Number(_loc3_) + 1)].push(tempy);
  111.             _loc2_ = _loc2_ + 1;
  112.          }
  113.          _loc3_ = _loc3_ + 1;
  114.       }
  115.       trace("total pickups on Level = " + home.totalPickups);
  116.       trace("=======");
  117.    }
  118.    var pus = home["pu_" + home.currentMap];
  119.    home.totalMapPickups = pus.length;
  120.    trace("Total pickups upon rendering map = " + pus.length);
  121.    _loc2_ = 0;
  122.    while(_loc2_ < home["pu_" + home.currentMap].length)
  123.    {
  124.       if(home["pu_" + home.currentMap][_loc2_] != undefined)
  125.       {
  126.          home.display.attachMovie("pickup","pickup" + _loc2_,1600 + _loc2_);
  127.          var namey = "pickup" + _loc2_;
  128.          home.display[namey].gotoAndStop(home["pu_" + home.currentMap][_loc2_][0]);
  129.          home.display[namey].id = _loc2_;
  130.          home.display[namey]._alpha = 100;
  131.          home.display[namey]._x = home["pu_" + home.currentMap][_loc2_][1] * TILE_W + TILE_W / 2;
  132.          home.display[namey]._y = home["pu_" + home.currentMap][_loc2_][2] * TILE_W + TILE_W / 2;
  133.       }
  134.       _loc2_ = _loc2_ + 1;
  135.    }
  136.    if(starting)
  137.    {
  138.       home.music.stop("music1");
  139.       home.music = new Sound();
  140.       home.music.attachSound("music1");
  141.       home.music.start(0,999);
  142.       charHits = 0;
  143.       resetHudHits();
  144.       home.invul = true;
  145.       home.respawn = true;
  146.       home.display.attachMovie("char","char",11000);
  147.       invul_interval = setInterval(checkInvul,invulLoopTime);
  148.       home.display.char.xpos = home["Level" + currentLevel].startPos[0] * TILE_W + TILE_W / 2;
  149.       home.display.char.ypos = home["Level" + currentLevel].startPos[1] * TILE_H + TILE_H / 2;
  150.    }
  151.    else
  152.    {
  153.       home.display.attachMovie("char","char",11000);
  154.       home.display.char._y = -200;
  155.       home.display.char.gummed = home.gummed;
  156.       home.display.char.bubble = home.bubble;
  157.       home.display.char.ypos = home.ypos;
  158.       home.display.char.xpos = home.xpos;
  159.       home.display.char.xspeed = home.xspeed;
  160.       home.display.char.yspeed = home.yspeed;
  161.       delete home.xspeed;
  162.       delete home.yspeed;
  163.    }
  164.    if(home.treadmill)
  165.    {
  166.       treadmill_snd = new Sound();
  167.       treadmill_snd.atcPlay("treadmill",999);
  168.    }
  169. }
  170. function nextMap(xpos, ypos, gummed, bubble, entry)
  171. {
  172.    var _loc1_ = xpos;
  173.    home.xspeed = home.display.char.xspeed;
  174.    home.yspeed = home.display.char.yspeed;
  175.    home.xpos = _loc1_;
  176.    home.ypos = 364;
  177.    home.gummed = gummed;
  178.    home.bubble = bubble;
  179.    home.starting = false;
  180.    if(_loc1_ < 45)
  181.    {
  182.       home.xpos = 55;
  183.    }
  184.    if(_loc1_ > 530)
  185.    {
  186.       home.xpos = 560;
  187.    }
  188.    home.currentMap = home.currentMap + 1;
  189.    var _loc2_ = home["Level" + home.currentLevel]["map" + home.currentMap];
  190.    buildMap(_loc2_);
  191. }
  192. function prevMap(xpos, ypos, gummed, bubble, entry)
  193. {
  194.    var _loc1_ = xpos;
  195.    home.xspeed = home.display.char.xspeed;
  196.    home.yspeed = home.display.char.yspeed;
  197.    home.xpos = _loc1_;
  198.    home.ypos = 10;
  199.    home.gummed = gummed;
  200.    home.bubble = bubble;
  201.    home.starting = false;
  202.    if(_loc1_ < 45)
  203.    {
  204.       home.xpos = 55;
  205.    }
  206.    if(_loc1_ > 530)
  207.    {
  208.       home.xpos = 560;
  209.    }
  210.    home.currentMap--;
  211.    var _loc2_ = home["Level" + home.currentLevel]["map" + home.currentMap];
  212.    buildMap(_loc2_);
  213. }
  214. function nextLevel()
  215. {
  216.    home.endLevel_mc.removeMovieClip();
  217.    clearInterval(home.timeInt);
  218.    clearInterval(home.invul_interval);
  219.    home.starting = true;
  220.    home.exit = false;
  221.    home.currentLevel = home.currentLevel + 1;
  222.    home.charAlive = true;
  223.    if(home.currentLevel > home.totalLevels)
  224.    {
  225.       trace("GAME COMPLETED");
  226.       gameComplete();
  227.    }
  228.    else
  229.    {
  230.       home.initTimer();
  231.       home.currentMap = home["Level" + home.currentLevel].currentMap;
  232.       var _loc1_ = home["Level" + home.currentLevel]["map" + home["Level" + home.currentLevel].currentMap];
  233.       buildMap(_loc1_);
  234.    }
  235. }
  236. function gameComplete()
  237. {
  238.    trace("Running End Screen function");
  239.    home.display.char.removeMovieClip();
  240.    home.attachMovie("endScreen","endScreen_mc",9999);
  241.    endScreen_mc.gotoAndStop(3);
  242.    win_snd = new Sound();
  243.    win_snd.atcPlay("fanfare");
  244.    home.endScreen_mc._x = Stage.width / 2;
  245.    home.endScreen_mc._y = Stage.height / 2;
  246. }
  247. function fpsInt()
  248. {
  249.    fps = ticks - oldticks + "/48";
  250.    oldticks = ticks;
  251. }
  252. function levelTimer()
  253. {
  254.    trace("levelTimer called: " + home.hud_BKG.timer_mc.timer);
  255.    if(home["Level" + home.currentLevel].levelTime - home.hud_BKG.timer_mc.timer == 0)
  256.    {
  257.       clearInterval(home.timeInt);
  258.       trace("timeUp!");
  259.       home.endGame(2);
  260.    }
  261.    else
  262.    {
  263.       home.hud_BKG.timer_mc.timer = home.hud_BKG.timer_mc.timer + 1;
  264.       home.hud_BKG.timer_mc.timeDisplay = home["Level" + home.currentLevel].levelTime - home.hud_BKG.timer_mc.timer;
  265.    }
  266.    if(home["Level" + home.currentLevel].levelTime - home.hud_BKG.timer_mc.timer == 5)
  267.    {
  268.       home.alrtsAdd("hurryUp");
  269.    }
  270. }
  271. function initTimer()
  272. {
  273.    trace("Level Timer Initiated");
  274.    home.hud_BKG.timer_mc.timer = 0;
  275.    home.hud_BKG.timer_mc.timeDisplay = home["Level" + home.currentLevel].levelTime;
  276.    home.timeInt = setInterval(levelTimer,1000);
  277. }
  278. function endGame(type)
  279. {
  280.    death_snd = new Sound();
  281.    death_snd.atcPlay("death");
  282.    trace("End Game Started");
  283.    clearInterval(home.timeInt);
  284.    clearInterval(home.invul_interval);
  285.    charArt.splat_mc._visible = false;
  286.    if(type == 1)
  287.    {
  288.       trace("GAME OVER: Too Many Enemy Hits!");
  289.       home.alrtsAdd("totallyChomped");
  290.    }
  291.    else
  292.    {
  293.       trace("GAME OVER: Out Of Time!");
  294.       home.alrtsAdd("timeIsUp");
  295.    }
  296.    delayItStart(2,home.alrtsAdd,"guhObj","guhObj2","gameOver");
  297.    delayItStart(7,home.endScreen,"guhObj","guhObj2");
  298.    home.charAlive = false;
  299.    home.charHits = 0;
  300.    home.exit = false;
  301.    currentLevel = 1;
  302.    home.display.char.bubble_mc._visible = false;
  303.    home.display.char.charArt.gotoAndStop("death");
  304. }
  305. function endScreen()
  306. {
  307.    trace("Running End Screen function");
  308.    home.display.char.removeMovieClip();
  309.    home.attachMovie("endScreen","endScreen_mc",9999);
  310.    home.endScreen_mc._x = Stage.width / 2;
  311.    home.endScreen_mc._y = Stage.height / 2;
  312. }
  313. function mainMenu()
  314. {
  315.    home.music.stop("music1");
  316.    home.hud_BKG.removeMovieClip();
  317.    home.display.removeMovieClip();
  318.    trace("Loading Main Menu");
  319.    home.attachMovie("mainMenu","mainMenu_mc",9999);
  320.    home.mainMenu_mc._x = Stage.width / 2;
  321.    home.mainMenu_mc._y = Stage.height / 2;
  322. }
  323. function respawn()
  324. {
  325.    trace("Respawn Invoked");
  326.    clearInterval(home.timeInt);
  327.    home.charAlive = true;
  328.    home.charHits = 0;
  329.    ticks;
  330.    home.starting = true;
  331.    home.currentMap = home["Level" + home.currentLevel].currentMap;
  332.    buildMap(home["Level" + home.currentLevel]["map" + home["Level" + home.currentLevel].currentMap]);
  333. }
  334. function resetHudHits()
  335. {
  336.    trace("Resetting HUD hits");
  337.    var _loc1_ = 1;
  338.    while(_loc1_ <= 5)
  339.    {
  340.       home.hud_BKG.health_mc["mark" + _loc1_].gotoAndStop(1);
  341.       _loc1_ = _loc1_ + 1;
  342.    }
  343. }
  344. function endLevel()
  345. {
  346.    function endLevel2()
  347.    {
  348.       home.alrts_mc.removeMovieClip();
  349.       home.attachMovie("endLevel","endLevel_mc",9999);
  350.       home.endLevel_mc.level.gotoAndStop(home.currentLevel);
  351.       home.endLevel_mc._x = Stage.width / 2;
  352.       home.endLevel_mc._y = Stage.height / 2;
  353.       var _loc3_ = home.itemsGrabbed;
  354.       var puMax = home.totalPickups;
  355.       var timeLeft = int(home["Level" + home.currentLevel].levelTime) - int(home.hud_BKG.timer_mc.timer);
  356.       var puPoints = puMax * home.puValue;
  357.       var _loc1_ = timeLeft * home.timeBonus;
  358.       var healthLeft = home.charHealth - home.CharHits;
  359.       var _loc2_ = healthLeft * home.healthBonus;
  360.       var total = _loc1_ + puPoints + _loc2_;
  361.       CumulativePoints["level" + home.currentLevel] = total;
  362.       CumulativePoints["puLevel" + home.currentLevel] = _loc3_;
  363.       home.endLevel_mc.healthPointsT = healthLeft + " x " + home.healthBonus + " = " + _loc2_;
  364.       home.endLevel_mc.timePointsT = timeLeft + " x " + home.timeBonus + " = " + _loc1_;
  365.       home.endLevel_mc.puPointsT = _loc3_ + " x " + home.puValue + " = " + puPoints;
  366.       home.endLevel_mc.total = total;
  367.       home.hud_BKG.points += _loc1_ + _loc2_;
  368.    }
  369.    home.music.stop();
  370.    endlevel_snd = new Sound();
  371.    endLevel_snd.atcPlay("levelEnd_snd");
  372.    trace("Ending Level");
  373.    clearInterval(home.timeInt);
  374.    clearInterval(home.invul_interval);
  375.    home.charAlive = false;
  376.    home.display.char.charArt.gotoAndStop("idle");
  377.    home.display.char.scaleTo(0,2,snapEase,0);
  378.    home.display.char.rotateTo(720,1.75,"",0.25);
  379.    home.display.char.slideTo(home.display.exit_mc._x - 10,home.display.exit_mc._y - 50,1.75,"",0.25,endLevel2);
  380. }
  381. function alrtsAdd(type)
  382. {
  383.    var _loc1_ = type;
  384.    if(_loc1_ == "portalOpen" || _loc1_ == "gameOver")
  385.    {
  386.       var _loc2_ = 5;
  387.    }
  388.    else if(_loc1_ == "timeIsUp")
  389.    {
  390.       _loc2_ = 3;
  391.    }
  392.    else
  393.    {
  394.       _loc2_ = 1;
  395.    }
  396.    home.alrts_mc.alrt_mc.stopTween();
  397.    home.alrts_mc.stopTween();
  398.    home.attachMovie("alrts","alrts_mc",9959);
  399.    home.alrts_mc.gotoAndStop(_loc1_);
  400.    home.alrts_mc.alrt_mc.stopTween();
  401.    home.alrts_mc.alrt_mc.scaleTo(100,1,home.elasto,0.25);
  402.    home.alrts_mc.alphaTo(10,1,"easeInQuad",_loc2_,home.alrtsRem);
  403. }
  404. function alrtsRem()
  405. {
  406.    home.alrts_mc.removeMovieClip();
  407. }
  408. function muteAll()
  409. {
  410.    if(home.music.getVolume() == 0)
  411.    {
  412.       home.music.setVolume(100);
  413.    }
  414.    else
  415.    {
  416.       home.music.setVolume(0);
  417.    }
  418. }
  419. Math.linearTween = function(t, b, c, d)
  420. {
  421.    return c * t / d + b;
  422. };
  423. Math.easeInQuad = function(t, b, c, d)
  424. {
  425.    return c * (t /= d) * t + b;
  426. };
  427. Math.easeOutQuad = function(t, b, c, d)
  428. {
  429.    return (- c) * (t /= d) * (t - 2) + b;
  430. };
  431. Math.easeInOutQuad = function(t, b, c, d)
  432. {
  433.    var _loc1_ = t;
  434.    if((_loc1_ /= d / 2) < 1)
  435.    {
  436.       return c / 2 * _loc1_ * _loc1_ + b;
  437.    }
  438.    return (- c) / 2 * ((_loc1_ = _loc1_ - 1) * (_loc1_ - 2) - 1) + b;
  439. };
  440. Math.easeOutInQuad = function(t, b, c, d)
  441. {
  442.    var _loc1_ = t;
  443.    if((_loc1_ /= d / 2) < 1)
  444.    {
  445.       return (- c) / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ - 1) + b;
  446.    }
  447.    return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ + 1) + b;
  448. };
  449. Math.easeInCubic = function(t, b, c, d)
  450. {
  451.    var _loc1_ = t;
  452.    return c * (_loc1_ /= d) * _loc1_ * _loc1_ + b;
  453. };
  454. Math.easeOutCubic = function(t, b, c, d)
  455. {
  456.    var _loc1_ = t;
  457.    return c * ((_loc1_ = _loc1_ / d - 1) * _loc1_ * _loc1_ + 1) + b;
  458. };
  459. Math.easeInOutCubic = function(t, b, c, d)
  460. {
  461.    var _loc1_ = t;
  462.    if((_loc1_ /= d / 2) < 1)
  463.    {
  464.       return c / 2 * _loc1_ * _loc1_ * _loc1_ + b;
  465.    }
  466.    return c / 2 * ((_loc1_ -= 2) * _loc1_ * _loc1_ + 2) + b;
  467. };
  468. Math.easeOutInCubic = function(t, b, c, d)
  469. {
  470.    var _loc1_ = t;
  471.    _loc1_ /= d / 2;
  472.    return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * _loc1_ + 1) + b;
  473. };
  474. Math.easeInQuart = function(t, b, c, d)
  475. {
  476.    var _loc1_ = t;
  477.    return c * (_loc1_ /= d) * _loc1_ * _loc1_ * _loc1_ + b;
  478. };
  479. Math.easeOutQuart = function(t, b, c, d)
  480. {
  481.    var _loc1_ = t;
  482.    return (- c) * ((_loc1_ = _loc1_ / d - 1) * _loc1_ * _loc1_ * _loc1_ - 1) + b;
  483. };
  484. Math.easeInOutQuart = function(t, b, c, d)
  485. {
  486.    var _loc1_ = t;
  487.    if((_loc1_ /= d / 2) < 1)
  488.    {
  489.       return c / 2 * _loc1_ * _loc1_ * _loc1_ * _loc1_ + b;
  490.    }
  491.    return (- c) / 2 * ((_loc1_ -= 2) * _loc1_ * _loc1_ * _loc1_ - 2) + b;
  492. };
  493. Math.easeOutInQuart = function(t, b, c, d)
  494. {
  495.    var _loc1_ = t;
  496.    if((_loc1_ /= d / 2) < 1)
  497.    {
  498.       return (- c) / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * _loc1_ * _loc1_ - 1) + b;
  499.    }
  500.    return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * _loc1_ * _loc1_ + 1) + b;
  501. };
  502. Math.easeInQuint = function(t, b, c, d)
  503. {
  504.    var _loc1_ = t;
  505.    return c * (_loc1_ /= d) * _loc1_ * _loc1_ * _loc1_ * _loc1_ + b;
  506. };
  507. Math.easeOutQuint = function(t, b, c, d)
  508. {
  509.    var _loc1_ = t;
  510.    return c * ((_loc1_ = _loc1_ / d - 1) * _loc1_ * _loc1_ * _loc1_ * _loc1_ + 1) + b;
  511. };
  512. Math.easeInOutQuint = function(t, b, c, d)
  513. {
  514.    var _loc1_ = t;
  515.    if((_loc1_ /= d / 2) < 1)
  516.    {
  517.       return c / 2 * _loc1_ * _loc1_ * _loc1_ * _loc1_ * _loc1_ + b;
  518.    }
  519.    return c / 2 * ((_loc1_ -= 2) * _loc1_ * _loc1_ * _loc1_ * _loc1_ + 2) + b;
  520. };
  521. Math.easeOutInQuint = function(t, b, c, d)
  522. {
  523.    var _loc1_ = t;
  524.    _loc1_ /= d / 2;
  525.    return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * _loc1_ * _loc1_ * _loc1_ + 1) + b;
  526. };
  527. Math.easeInSine = function(t, b, c, d)
  528. {
  529.    return (- c) * Math.cos(t / d * 1.5707963267948966) + c + b;
  530. };
  531. Math.easeOutSine = function(t, b, c, d)
  532. {
  533.    return c * Math.sin(t / d * 1.5707963267948966) + b;
  534. };
  535. Math.easeInOutSine = function(t, b, c, d)
  536. {
  537.    return (- c) / 2 * (Math.cos(3.141592653589793 * t / d) - 1) + b;
  538. };
  539. Math.easeOutInSine = function(t, b, c, d)
  540. {
  541.    var _loc1_ = t;
  542.    if((_loc1_ /= d / 2) < 1)
  543.    {
  544.       return c / 2 * Math.sin(3.141592653589793 * _loc1_ / 2) + b;
  545.    }
  546.    return (- c) / 2 * (Math.cos(3.141592653589793 * (_loc1_ = _loc1_ - 1) / 2) - 2) + b;
  547. };
  548. Math.easeInExpo = function(t, b, c, d)
  549. {
  550.    return t != 0 ? c * Math.pow(2,10 * (t / d - 1)) + b : b;
  551. };
  552. Math.easeOutExpo = function(t, b, c, d)
  553. {
  554.    return t != d ? c * (- Math.pow(2,-10 * t / d) + 1) + b : b + c;
  555. };
  556. Math.easeInOutExpo = function(t, b, c, d)
  557. {
  558.    var _loc1_ = t;
  559.    var _loc2_ = b;
  560.    var _loc3_ = c;
  561.    if(_loc1_ == 0)
  562.    {
  563.       return _loc2_;
  564.    }
  565.    if(_loc1_ == d)
  566.    {
  567.       return _loc2_ + _loc3_;
  568.    }
  569.    if((_loc1_ /= d / 2) < 1)
  570.    {
  571.       return _loc3_ / 2 * Math.pow(2,10 * (_loc1_ - 1)) + _loc2_;
  572.    }
  573.    return _loc3_ / 2 * (- Math.pow(2,-10 * (_loc1_ = _loc1_ - 1)) + 2) + _loc2_;
  574. };
  575. Math.easeOutInExpo = function(t, b, c, d)
  576. {
  577.    var _loc1_ = t;
  578.    var _loc2_ = b;
  579.    var _loc3_ = c;
  580.    if(_loc1_ == 0)
  581.    {
  582.       return _loc2_;
  583.    }
  584.    if(_loc1_ == d)
  585.    {
  586.       return _loc2_ + _loc3_;
  587.    }
  588.    if((_loc1_ /= d / 2) < 1)
  589.    {
  590.       return _loc3_ / 2 * (- Math.pow(2,-10 * _loc1_) + 1) + _loc2_;
  591.    }
  592.    return _loc3_ / 2 * (Math.pow(2,10 * (_loc1_ - 2)) + 1) + _loc2_;
  593. };
  594. Math.easeInCirc = function(t, b, c, d)
  595. {
  596.    return (- c) * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
  597. };
  598. Math.easeOutCirc = function(t, b, c, d)
  599. {
  600.    var _loc1_ = t;
  601.    return c * Math.sqrt(1 - (_loc1_ = _loc1_ / d - 1) * _loc1_) + b;
  602. };
  603. Math.easeInOutCirc = function(t, b, c, d)
  604. {
  605.    var _loc1_ = t;
  606.    if((_loc1_ /= d / 2) < 1)
  607.    {
  608.       return (- c) / 2 * (Math.sqrt(1 - _loc1_ * _loc1_) - 1) + b;
  609.    }
  610.    return c / 2 * (Math.sqrt(1 - (_loc1_ -= 2) * _loc1_) + 1) + b;
  611. };
  612. Math.easeOutInCirc = function(t, b, c, d)
  613. {
  614.    var _loc1_ = t;
  615.    if((_loc1_ /= d / 2) < 1)
  616.    {
  617.       return c / 2 * Math.sqrt(1 - (_loc1_ = _loc1_ - 1) * _loc1_) + b;
  618.    }
  619.    return c / 2 * (2 - Math.sqrt(1 - (_loc1_ = _loc1_ - 1) * _loc1_)) + b;
  620. };
  621. Math.easeInElastic = function(t, b, c, d, a, p)
  622. {
  623.    var _loc1_ = p;
  624.    var _loc2_ = t;
  625.    var _loc3_ = c;
  626.    if(_loc2_ == 0)
  627.    {
  628.       return b;
  629.    }
  630.    if((_loc2_ /= d) == 1)
  631.    {
  632.       return b + _loc3_;
  633.    }
  634.    if(!_loc1_)
  635.    {
  636.       _loc1_ = d * 0.3;
  637.    }
  638.    if(a < Math.abs(_loc3_))
  639.    {
  640.       a = _loc3_;
  641.       var s = _loc1_ / 4;
  642.    }
  643.    else
  644.    {
  645.       var s = _loc1_ / 6.283185307179586 * Math.asin(_loc3_ / a);
  646.    }
  647.    return - a * Math.pow(2,10 * (_loc2_ -= 1)) * Math.sin((_loc2_ * d - s) * 6.283185307179586 / _loc1_) + b;
  648. };
  649. Math.easeOutElastic = function(t, b, c, d, a, p)
  650. {
  651.    var _loc1_ = c;
  652.    var _loc2_ = p;
  653.    var _loc3_ = t;
  654.    if(_loc3_ == 0)
  655.    {
  656.       return b;
  657.    }
  658.    if((_loc3_ /= d) == 1)
  659.    {
  660.       return b + _loc1_;
  661.    }
  662.    if(!_loc2_)
  663.    {
  664.       _loc2_ = d * 0.3;
  665.    }
  666.    if(a < Math.abs(_loc1_))
  667.    {
  668.       a = _loc1_;
  669.       var s = _loc2_ / 4;
  670.    }
  671.    else
  672.    {
  673.       var s = _loc2_ / 6.283185307179586 * Math.asin(_loc1_ / a);
  674.    }
  675.    return a * Math.pow(2,-10 * _loc3_) * Math.sin((_loc3_ * d - s) * 6.283185307179586 / _loc2_) + _loc1_ + b;
  676. };
  677. Math.easeInOutElastic = function(t, b, c, d, a, p)
  678. {
  679.    var _loc1_ = t;
  680.    var _loc2_ = p;
  681.    var _loc3_ = c;
  682.    if(_loc1_ == 0)
  683.    {
  684.       return b;
  685.    }
  686.    if((_loc1_ /= d / 2) == 2)
  687.    {
  688.       return b + _loc3_;
  689.    }
  690.    if(!_loc2_)
  691.    {
  692.       _loc2_ = d * 0.44999999999999996;
  693.    }
  694.    if(a < Math.abs(_loc3_))
  695.    {
  696.       a = _loc3_;
  697.       var s = _loc2_ / 4;
  698.    }
  699.    else
  700.    {
  701.       var s = _loc2_ / 6.283185307179586 * Math.asin(_loc3_ / a);
  702.    }
  703.    if(_loc1_ < 1)
  704.    {
  705.       return -0.5 * (a * Math.pow(2,10 * (_loc1_ = _loc1_ - 1)) * Math.sin((_loc1_ * d - s) * 6.283185307179586 / _loc2_)) + b;
  706.    }
  707.    return a * Math.pow(2,-10 * (_loc1_ = _loc1_ - 1)) * Math.sin((_loc1_ * d - s) * 6.283185307179586 / _loc2_) * 0.5 + _loc3_ + b;
  708. };
  709. Math.easeOutInElastic = function(t, b, c, d, a, p)
  710. {
  711.    var _loc1_ = t;
  712.    var _loc2_ = c;
  713.    var _loc3_ = p;
  714.    if(_loc1_ == 0)
  715.    {
  716.       return b;
  717.    }
  718.    if((_loc1_ /= d / 2) == 2)
  719.    {
  720.       return b + _loc2_;
  721.    }
  722.    if(!_loc3_)
  723.    {
  724.       _loc3_ = d * 0.44999999999999996;
  725.    }
  726.    if(a < Math.abs(_loc2_))
  727.    {
  728.       a = _loc2_;
  729.       var s = _loc3_ / 4;
  730.    }
  731.    else
  732.    {
  733.       var s = _loc3_ / 6.283185307179586 * Math.asin(_loc2_ / a);
  734.    }
  735.    if(_loc1_ < 1)
  736.    {
  737.       return 0.5 * (a * Math.pow(2,-10 * _loc1_) * Math.sin((_loc1_ * d - s) * 6.283185307179586 / _loc3_)) + _loc2_ / 2 + b;
  738.    }
  739.    return _loc2_ / 2 + 0.5 * (a * Math.pow(2,10 * (_loc1_ - 2)) * Math.sin((_loc1_ * d - s) * 6.283185307179586 / _loc3_)) + b;
  740. };
  741. Math.easeInBack = function(t, b, c, d, s)
  742. {
  743.    var _loc1_ = s;
  744.    var _loc2_ = t;
  745.    if(_loc1_ == undefined)
  746.    {
  747.       _loc1_ = 1.70158;
  748.    }
  749.    return c * (_loc2_ /= d) * _loc2_ * ((_loc1_ + 1) * _loc2_ - _loc1_) + b;
  750. };
  751. Math.easeOutBack = function(t, b, c, d, s)
  752. {
  753.    var _loc1_ = t;
  754.    var _loc2_ = s;
  755.    if(_loc2_ == undefined)
  756.    {
  757.       _loc2_ = 1.70158;
  758.    }
  759.    return c * ((_loc1_ = _loc1_ / d - 1) * _loc1_ * ((_loc2_ + 1) * _loc1_ + _loc2_) + 1) + b;
  760. };
  761. Math.easeInOutBack = function(t, b, c, d, s)
  762. {
  763.    var _loc1_ = t;
  764.    var _loc2_ = s;
  765.    if(_loc2_ == undefined)
  766.    {
  767.       _loc2_ = 1.70158;
  768.    }
  769.    if((_loc1_ /= d / 2) < 1)
  770.    {
  771.       return c / 2 * (_loc1_ * _loc1_ * (((_loc2_ *= 1.525) + 1) * _loc1_ - _loc2_)) + b;
  772.    }
  773.    return c / 2 * ((_loc1_ -= 2) * _loc1_ * (((_loc2_ *= 1.525) + 1) * _loc1_ + _loc2_) + 2) + b;
  774. };
  775. Math.easeOutInBack = function(t, b, c, d, s)
  776. {
  777.    var _loc1_ = t;
  778.    var _loc2_ = s;
  779.    if(_loc2_ == undefined)
  780.    {
  781.       _loc2_ = 1.70158;
  782.    }
  783.    if((_loc1_ /= d / 2) < 1)
  784.    {
  785.       return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * (((_loc2_ *= 1.525) + 1) * _loc1_ + _loc2_) + 1) + b;
  786.    }
  787.    return c / 2 * ((_loc1_ = _loc1_ - 1) * _loc1_ * (((_loc2_ *= 1.525) + 1) * _loc1_ - _loc2_) + 1) + b;
  788. };
  789. Math.easeInBounce = function(t, b, c, d)
  790. {
  791.    return c - Math.easeOutBounce(d - t,0,c,d) + b;
  792. };
  793. Math.easeOutBounce = function(t, b, c, d)
  794. {
  795.    var _loc1_ = t;
  796.    var _loc2_ = c;
  797.    var _loc3_ = b;
  798.    if((_loc1_ /= d) < 0.36363636363636365)
  799.    {
  800.       return _loc2_ * (7.5625 * _loc1_ * _loc1_) + _loc3_;
  801.    }
  802.    if(_loc1_ < 0.7272727272727273)
  803.    {
  804.       return _loc2_ * (7.5625 * (_loc1_ -= 0.5454545454545454) * _loc1_ + 0.75) + _loc3_;
  805.    }
  806.    if(_loc1_ < 0.9090909090909091)
  807.    {
  808.       return _loc2_ * (7.5625 * (_loc1_ -= 0.8181818181818182) * _loc1_ + 0.9375) + _loc3_;
  809.    }
  810.    return _loc2_ * (7.5625 * (_loc1_ -= 0.9545454545454546) * _loc1_ + 0.984375) + _loc3_;
  811. };
  812. Math.easeInOutBounce = function(t, b, c, d)
  813. {
  814.    var _loc1_ = d;
  815.    var _loc2_ = t;
  816.    var _loc3_ = c;
  817.    if(_loc2_ < _loc1_ / 2)
  818.    {
  819.       return Math.easeInBounce(_loc2_ * 2,0,_loc3_,_loc1_) * 0.5 + b;
  820.    }
  821.    return Math.easeOutBounce(_loc2_ * 2 - _loc1_,0,_loc3_,_loc1_) * 0.5 + _loc3_ * 0.5 + b;
  822. };
  823. Math.easeOutInBounce = function(t, b, c, d)
  824. {
  825.    var _loc1_ = d;
  826.    var _loc2_ = t;
  827.    var _loc3_ = c;
  828.    if(_loc2_ < _loc1_ / 2)
  829.    {
  830.       return Math.easeOutBounce(_loc2_ * 2,0,_loc3_,_loc1_) * 0.5 + b;
  831.    }
  832.    return Math.easeInBounce(_loc2_ * 2 - _loc1_,0,_loc3_,_loc1_) * 0.5 + _loc3_ * 0.5 + b;
  833. };
  834. var Mp = MovieClip.prototype;
  835. Mp.addListener = function()
  836. {
  837.    var _loc1_ = this;
  838.    if(!_loc1_._listeners)
  839.    {
  840.       AsBroadcaster.initialize(_loc1_);
  841.    }
  842.    _loc1_.addListener.apply(_loc1_,arguments);
  843. };
  844. ASSetPropFlags(Mp,"addListener",1,0);
  845. var tp = tweenManager.prototype;
  846. tp.setupdateInterval = function(time)
  847. {
  848.    var _loc1_ = this;
  849.    if(_loc1_.playing)
  850.    {
  851.       _loc1_.deinit();
  852.       _loc1_.updateTime = time;
  853.       _loc1_.init();
  854.    }
  855.    else
  856.    {
  857.       _loc1_.updateTime = time;
  858.    }
  859. };
  860. tp.getupdateInterval = function()
  861. {
  862.    return this.updateTime;
  863. };
  864. tp.addProperty("updateInterval",tp.getupdateInterval,tp.setupdateInterval);
  865. tp.init = function()
  866. {
  867.    var tm = this;
  868.    if(tm.updateTime > 0)
  869.    {
  870.       tm.updateIntId = setInterval(tm,"update",tm.updateTime);
  871.    }
  872.    else
  873.    {
  874.       if(tm.tweenHolder._name == undefined)
  875.       {
  876.          tm.tweenHolder = _root.createEmptyMovieClip("_th_",-6789);
  877.       }
  878.       tm.tweenHolder.onEnterFrame = function()
  879.       {
  880.          tm.update.call(tm);
  881.       };
  882.    }
  883.    tm.playing = true;
  884.    tm.now = getTimer();
  885. };
  886. tp.deinit = function()
  887. {
  888.    var _loc1_ = this;
  889.    _loc1_.playing = false;
  890.    clearInterval(_loc1_.updateIntId);
  891.    delete _loc1_.tweenHolder.onEnterFrame;
  892. };
  893. tp.update = function()
  894. {
  895.    var i;
  896.    var _loc1_ = undefined;
  897.    var _loc2_ = undefined;
  898.    var _loc3_ = undefined;
  899.    i = this.tweenList.length;
  900.    if(this.broadcastEvents)
  901.    {
  902.       var ut = {};
  903.       var et = {};
  904.    }
  905.    while(i--)
  906.    {
  907.       _loc1_ = this.tweenList[i];
  908.       if(_loc1_.ts + _loc1_.d > this.now)
  909.       {
  910.          if(_loc1_.ctm == undefined)
  911.          {
  912.             _loc1_.mc[_loc1_.pp] = _loc1_.ef(this.now - _loc1_.ts,_loc1_.ps,_loc1_.ch,_loc1_.d,_loc1_.e1,_loc1_.e2);
  913.          }
  914.          else
  915.          {
  916.             _loc3_ = {};
  917.             for(_loc2_ in _loc1_.ctm)
  918.             {
  919.                _loc3_[_loc2_] = _loc1_.ef(this.now - _loc1_.ts,_loc1_.stm[_loc2_],_loc1_.ctm[_loc2_],_loc1_.d,_loc1_.e1,_loc1_.e2);
  920.             }
  921.             _loc1_.c.setTransform(_loc3_);
  922.          }
  923.          if(this.broadcastEvents && ut[targetPath(_loc1_.mc)] == undefined)
  924.          {
  925.             ut[targetPath(_loc1_.mc)] = _loc1_.mc;
  926.          }
  927.          if(_loc1_.cb.updfunc != undefined)
  928.          {
  929.             _loc1_.cb.updfunc.apply(_loc1_.cb.updscope,_loc1_.cb.updargs);
  930.          }
  931.       }
  932.       else
  933.       {
  934.          if(_loc1_.ctm == undefined)
  935.          {
  936.             _loc1_.mc[_loc1_.pp] = _loc1_.ps + _loc1_.ch;
  937.          }
  938.          else
  939.          {
  940.             _loc3_ = {};
  941.             for(_loc2_ in _loc1_.ctm)
  942.             {
  943.                _loc3_[_loc2_] = _loc1_.stm[_loc2_] + _loc1_.ctm[_loc2_];
  944.             }
  945.             _loc1_.c.setTransform(_loc3_);
  946.          }
  947.          if(this.broadcastEvents)
  948.          {
  949.             if(ut[targetPath(_loc1_.mc)] == undefined)
  950.             {
  951.                ut[targetPath(_loc1_.mc)] = _loc1_.mc;
  952.             }
  953.             if(et[targetPath(_loc1_.mc)] == undefined)
  954.             {
  955.                et[targetPath(_loc1_.mc)] = _loc1_.mc;
  956.             }
  957.          }
  958.          if(_loc1_.cb.updfunc != undefined)
  959.          {
  960.             _loc1_.cb.updfunc.apply(_loc1_.cb.updscope,_loc1_.cb.updargs);
  961.          }
  962.          if(endt == undefined)
  963.          {
  964.             var endt = new Array();
  965.          }
  966.          endt.push(i);
  967.       }
  968.    }
  969.    for(_loc2_ in ut)
  970.    {
  971.       ut[_loc2_].broadcastMessage("onTweenUpdate");
  972.    }
  973.    if(endt != undefined)
  974.    {
  975.       this.endTweens(endt);
  976.    }
  977.    for(_loc2_ in et)
  978.    {
  979.       et[_loc2_].broadcastMessage("onTweenEnd");
  980.    }
  981.    this.now = getTimer();
  982.    if(this.updateTime > 0)
  983.    {
  984.       updateAfterEvent();
  985.    }
  986. };
  987. tp.endTweens = function(tid_arr)
  988. {
  989.    var cb_arr;
  990.    var tl;
  991.    var i;
  992.    var cb;
  993.    var j;
  994.    cb_arr = [];
  995.    tl = tid_arr.length;
  996.    with(this)
  997.    {
  998.       i = 0;
  999.       while(i < tl)
  1000.       {
  1001.          cb = tweenList[tid_arr[i]].cb;
  1002.          if(cb != undefined)
  1003.          {
  1004.             var exec = true;
  1005.             for(j in cb_arr)
  1006.             {
  1007.                if(cb_arr[j] == cb)
  1008.                {
  1009.                   exec = false;
  1010.                   break;
  1011.                }
  1012.             }
  1013.             if(exec)
  1014.             {
  1015.                cb_arr.push(cb);
  1016.             }
  1017.          }
  1018.          tweenList.splice(tid_arr[i],1);
  1019.          i++;
  1020.       }
  1021.       i = 0;
  1022.       while(i < cb_arr.length)
  1023.       {
  1024.          cb_arr[i].func.apply(cb_arr[i].scope,cb_arr[i].args);
  1025.          i++;
  1026.       }
  1027.       if(tweenList.length == 0)
  1028.       {
  1029.          deinit();
  1030.       }
  1031.    }
  1032. };
  1033. tp.addTween = function(mc, props, pEnd, sec, eqFunc, callback, extra1, extra2)
  1034. {
  1035.    var i;
  1036.    var pp;
  1037.    var addnew;
  1038.    var j;
  1039.    var t;
  1040.    with(this)
  1041.    {
  1042.       if(!playing)
  1043.       {
  1044.          init();
  1045.       }
  1046.       for(i in props)
  1047.       {
  1048.          pp = props[i];
  1049.          addnew = true;
  1050.          if(pp.substr(0,4) != "_ct_")
  1051.          {
  1052.             if(autoOverwrite)
  1053.             {
  1054.                for(j in tweenList)
  1055.                {
  1056.                   t = tweenList[j];
  1057.                   if(t.mc == mc && t.pp == pp)
  1058.                   {
  1059.                      t.ps = mc[pp];
  1060.                      t.ch = pEnd[i] - mc[pp];
  1061.                      t.ts = now;
  1062.                      t.d = sec * 1000;
  1063.                      t.ef = eqFunc;
  1064.                      t.cb = callback;
  1065.                      t.e1 = extra1;
  1066.                      t.e2 = extra2;
  1067.                      addnew = false;
  1068.                      break;
  1069.                   }
  1070.                }
  1071.             }
  1072.             if(addnew)
  1073.             {
  1074.                tweenList.unshift({mc:mc,pp:pp,ps:mc[pp],ch:pEnd[i] - mc[pp],ts:now,d:sec * 1000,ef:eqFunc,cb:callback,e1:extra1,e2:extra2});
  1075.             }
  1076.          }
  1077.          else
  1078.          {
  1079.             var c = new Color(mc);
  1080.             var stm = c.getTransform();
  1081.             var ctm = {};
  1082.             for(j in pEnd[i])
  1083.             {
  1084.                if(pEnd[i][j] != stm[j] && pEnd[i][j] != undefined)
  1085.                {
  1086.                   ctm[j] = pEnd[i][j] - stm[j];
  1087.                }
  1088.             }
  1089.             if(autoOverwrite)
  1090.             {
  1091.                for(j in tweenList)
  1092.                {
  1093.                   t = tweenList[j];
  1094.                   if(t.mc == mc && t.ctm != undefined)
  1095.                   {
  1096.                      t.c = c;
  1097.                      t.stm = stm;
  1098.                      t.ctm = ctm;
  1099.                      t.ts = now;
  1100.                      t.d = sec * 1000;
  1101.                      t.ef = eqFunc;
  1102.                      t.cb = callback;
  1103.                      t.e1 = extra1;
  1104.                      t.e2 = extra2;
  1105.                      addnew = false;
  1106.                      break;
  1107.                   }
  1108.                }
  1109.             }
  1110.             if(addnew)
  1111.             {
  1112.                tweenList.unshift({mc:mc,c:c,stm:stm,ctm:ctm,ts:now,d:sec * 1000,ef:eqFunc,cb:callback,e1:extra1,e2:extra2});
  1113.             }
  1114.          }
  1115.       }
  1116.       if(broadcastEvents)
  1117.       {
  1118.          mc.broadcastMessage("onTweenStart");
  1119.       }
  1120.       if(callback.startfunc != undefined)
  1121.       {
  1122.          callback.startfunc.apply(callback.startscope,callback.startargs);
  1123.       }
  1124.    }
  1125. };
  1126. tp.addTweenWithDelay = function(delay, mc, props, pEnd, sec, eqFunc, callback, extra1, extra2)
  1127. {
  1128.    with(this)
  1129.    {
  1130.       var il;
  1131.       var intid;
  1132.       il = ints.length;
  1133.       intid = setInterval(function(obj)
  1134.       {
  1135.          var _loc1_ = obj;
  1136.          var _loc3_ = undefined;
  1137.          var _loc2_ = undefined;
  1138.          _loc1_.addTween(mc,props,pEnd,sec,eqFunc,callback,extra1,extra2);
  1139.          clearInterval(_loc1_.ints[il].intid);
  1140.          _loc1_.ints[il] = undefined;
  1141.          _loc3_ = true;
  1142.          for(_loc2_ in _loc1_.ints)
  1143.          {
  1144.             if(_loc1_.ints[_loc2_] != undefined)
  1145.             {
  1146.                _loc3_ = false;
  1147.                break;
  1148.             }
  1149.          }
  1150.          if(_loc3_)
  1151.          {
  1152.             _loc1_.ints = [];
  1153.          }
  1154.       }
  1155.       ,delay * 1000,this);
  1156.       ints[il] = {mc:mc,props:props,pend:pEnd,intid:intid,st:this.now,delay:delay * 1000,args:arguments.slice(1)};
  1157.    }
  1158. };
  1159. tp.removeTween = function(mc, props)
  1160. {
  1161.    with(this)
  1162.    {
  1163.       var all;
  1164.       var i;
  1165.       var j;
  1166.       all = false;
  1167.       if(props == undefined)
  1168.       {
  1169.          all = true;
  1170.       }
  1171.       i = tweenList.length;
  1172.       while(i--)
  1173.       {
  1174.          if(tweenList[i].mc == mc)
  1175.          {
  1176.             if(all)
  1177.             {
  1178.                tweenList.splice(i,1);
  1179.             }
  1180.             else
  1181.             {
  1182.                for(j in props)
  1183.                {
  1184.                   if(tweenList[i].pp == props[j])
  1185.                   {
  1186.                      tweenList.splice(i,1);
  1187.                   }
  1188.                   else if(props[j] == "_ct_" && tweenList[i].ctm != undefined)
  1189.                   {
  1190.                      tweenList.splice(i,1);
  1191.                   }
  1192.                }
  1193.             }
  1194.          }
  1195.       }
  1196.       i = ints.length;
  1197.       while(i--)
  1198.       {
  1199.          if(ints[i].mc == mc)
  1200.          {
  1201.             if(all)
  1202.             {
  1203.                clearInterval(ints[i].intid);
  1204.                ints[i] = undefined;
  1205.             }
  1206.             else
  1207.             {
  1208.                for(j in props)
  1209.                {
  1210.                   for(var k in ints[i].props)
  1211.                   {
  1212.                      if(ints[i].props[k] == props[j])
  1213.                      {
  1214.                         ints[i].props.splice(k,1);
  1215.                         ints[i].pend.splice(k,1);
  1216.                      }
  1217.                   }
  1218.                   if(ints[i].props.length == 0)
  1219.                   {
  1220.                      clearInterval(ints[i].intid);
  1221.                      ints[i] = undefined;
  1222.                   }
  1223.                }
  1224.             }
  1225.          }
  1226.       }
  1227.       if(tweenList.length == 0)
  1228.       {
  1229.          deinit();
  1230.       }
  1231.    }
  1232. };
  1233. tp.isTweening = function(mc)
  1234. {
  1235.    with(this)
  1236.    {
  1237.       for(var i in tweenList)
  1238.       {
  1239.          if(tweenList[i].mc == mc)
  1240.          {
  1241.             return true;
  1242.          }
  1243.       }
  1244.       return false;
  1245.    }
  1246. };
  1247. tp.getTweens = function(mc)
  1248. {
  1249.    with(this)
  1250.    {
  1251.       var count = 0;
  1252.       for(var i in tweenList)
  1253.       {
  1254.          if(tweenList[i].mc == mc)
  1255.          {
  1256.             count++;
  1257.          }
  1258.       }
  1259.       return count;
  1260.    }
  1261. };
  1262. tp.lockTween = function(mc, bool)
  1263. {
  1264.    this.lockedTweens[targetPath(mc)] = bool;
  1265. };
  1266. tp.isTweenLocked = function(mc)
  1267. {
  1268.    if(this.lockedTweens[targetPath(mc)] == undefined)
  1269.    {
  1270.       return false;
  1271.    }
  1272.    return this.lockedTweens[targetPath(mc)];
  1273. };
  1274. tp.pauseAll = function()
  1275. {
  1276.    var _loc1_ = this;
  1277.    if(!_loc1_.isPaused)
  1278.    {
  1279.       _loc1_.isPaused = true;
  1280.       _loc1_.pausedTime = _loc1_.now;
  1281.       for(var _loc2_ in _loc1_.ints)
  1282.       {
  1283.          clearInterval(_loc1_.ints[_loc2_].intid);
  1284.       }
  1285.       _loc1_.deinit();
  1286.    }
  1287. };
  1288. tp.unpauseAll = function()
  1289. {
  1290.    var _loc1_ = this;
  1291.    if(_loc1_.isPaused)
  1292.    {
  1293.       var _loc2_ = undefined;
  1294.       var t;
  1295.       _loc1_.isPaused = false;
  1296.       _loc1_.now = getTimer();
  1297.       for(_loc2_ in _loc1_.tweenList)
  1298.       {
  1299.          t = _loc1_.tweenList[_loc2_];
  1300.          t.ts = _loc1_.now - (_loc1_.pausedTime - t.ts);
  1301.       }
  1302.       _loc1_.init();
  1303.       for(_loc2_ in _loc1_.ints)
  1304.       {
  1305.          if(_loc1_.ints[_loc2_] != undefined)
  1306.          {
  1307.             var _loc3_ = _loc1_.ints[_loc2_].delay - (_loc1_.pausedTime - _loc1_.ints[_loc2_].st);
  1308.             var intid = setInterval(function(obj, id)
  1309.             {
  1310.                var _loc1_ = obj;
  1311.                var _loc2_ = id;
  1312.                _loc1_.addTween.apply(_loc1_,_loc1_.ints[_loc2_].args);
  1313.                clearInterval(_loc1_.ints[_loc2_].intid);
  1314.                _loc1_.ints[_loc2_] = undefined;
  1315.             }
  1316.             ,_loc3_,_loc1_,_loc2_);
  1317.             _loc1_.ints[_loc2_].intid = intid;
  1318.             _loc1_.ints[_loc2_].st = _loc1_.now;
  1319.             _loc1_.ints[_loc2_].delay = _loc3_;
  1320.          }
  1321.       }
  1322.    }
  1323. };
  1324. tp.toString = function()
  1325. {
  1326.    return "[AS1 tweenManager 1.1.8]";
  1327. };
  1328. delete tp;
  1329. if(_global.$tweenManager == undefined)
  1330. {
  1331.    _global.$tweenManager = new tweenManager();
  1332. }
  1333. else
  1334. {
  1335.    _global.$tweenManager.playing = false;
  1336. }
  1337. Mp.tween = function(props, pEnd, seconds, animType, delay, callback, extra1, extra2)
  1338. {
  1339.    if(_global.$tweenManager.isTweenLocked(this))
  1340.    {
  1341.       trace("error: this movieclip is locked");
  1342.       return undefined;
  1343.    }
  1344.    if(arguments.length < 2)
  1345.    {
  1346.       trace("error: props & pEnd must be defined");
  1347.       return undefined;
  1348.    }
  1349.    if(typeof props == "string")
  1350.    {
  1351.       props = [props];
  1352.    }
  1353.    if(pEnd.length == undefined)
  1354.    {
  1355.       pEnd = [pEnd];
  1356.    }
  1357.    if(seconds == undefined)
  1358.    {
  1359.       seconds = 2;
  1360.    }
  1361.    else if(seconds < 0.01)
  1362.    {
  1363.       seconds = 0;
  1364.    }
  1365.    if(delay < 0.01 || delay == undefined)
  1366.    {
  1367.       delay = 0;
  1368.    }
  1369.    switch(typeof animType)
  1370.    {
  1371.       case "string":
  1372.          if(animType.toLowerCase() == "linear")
  1373.          {
  1374.             var eqf = Math.linearTween;
  1375.          }
  1376.          else
  1377.          {
  1378.             var eqf = Math[animType];
  1379.          }
  1380.          break;
  1381.       case "function":
  1382.          var eqf = animType;
  1383.          break;
  1384.       case "object":
  1385.          if(animType.pts != undefined && animType.ease != undefined)
  1386.          {
  1387.             var eqf = animType.ease;
  1388.             var extra1 = animType.pts;
  1389.             break;
  1390.          }
  1391.    }
  1392.    if(eqf == undefined)
  1393.    {
  1394.       var eqf = Math.easeOutExpo;
  1395.    }
  1396.    switch(typeof callback)
  1397.    {
  1398.       case "function":
  1399.          callback = {func:callback,scope:this._parent};
  1400.          break;
  1401.       case "string":
  1402.          var ilp = callback.indexOf("(");
  1403.          var funcp = callback.slice(0,ilp);
  1404.          var scope = eval(funcp.slice(0,funcp.lastIndexOf(".")));
  1405.          var func = eval(funcp);
  1406.          var args = callback.slice(ilp + 1,callback.lastIndexOf(")")).split(",");
  1407.          var i = 0;
  1408.          while(i < args.length)
  1409.          {
  1410.             var a = eval(args[i]);
  1411.             if(a != undefined)
  1412.             {
  1413.                args[i] = a;
  1414.             }
  1415.             i++;
  1416.          }
  1417.          callback = {func:func,scope:scope,args:args};
  1418.    }
  1419.    if(_global.$tweenManager.autoStop)
  1420.    {
  1421.       _global.$tweenManager.removeTween(this,props);
  1422.    }
  1423.    if(delay > 0)
  1424.    {
  1425.       _global.$tweenManager.addTweenWithDelay(delay,this,props,pEnd,seconds,eqf,callback,extra1,extra2);
  1426.    }
  1427.    else
  1428.    {
  1429.       _global.$tweenManager.addTween(this,props,pEnd,seconds,eqf,callback,extra1,extra2);
  1430.    }
  1431. };
  1432. ASSetPropFlags(Mp,"tween",1,0);
  1433. Mp.stopTween = function(props)
  1434. {
  1435.    var _loc1_ = props;
  1436.    if(typeof _loc1_ == "string")
  1437.    {
  1438.       _loc1_ = [_loc1_];
  1439.    }
  1440.    _global.$tweenManager.removeTween(this,_loc1_);
  1441. };
  1442. ASSetPropFlags(Mp,"stopTween",1,0);
  1443. Mp.isTweening = function()
  1444. {
  1445.    return _global.$tweenManager.isTweening(this);
  1446. };
  1447. ASSetPropFlags(Mp,"isTweening",1,0);
  1448. Mp.getTweens = function()
  1449. {
  1450.    return _global.$tweenManager.getTweens(this);
  1451. };
  1452. ASSetPropFlags(Mp,"getTweens",1,0);
  1453. Mp.lockTween = function()
  1454. {
  1455.    _global.$tweenManager.lockTween(this,true);
  1456. };
  1457. ASSetPropFlags(Mp,"lockTween",1,0);
  1458. Mp.unlockTween = function()
  1459. {
  1460.    _global.$tweenManager.lockTween(this,false);
  1461. };
  1462. ASSetPropFlags(Mp,"unlockTween",1,0);
  1463. Mp.isTweenLocked = function()
  1464. {
  1465.    return _global.$tweenManager.isTweenLocked(this);
  1466. };
  1467. ASSetPropFlags(Mp,"isTweenLocked",1,0);
  1468. Mp.alphaTo = function(destAlpha, seconds, animType, delay, callback, extra1, extra2)
  1469. {
  1470.    this.tween(["_alpha"],[destAlpha],seconds,animType,delay,callback,extra1,extra2);
  1471. };
  1472. ASSetPropFlags(Mp,"alphaTo",1,0);
  1473. Mp.brightnessTo = function(bright, seconds, animType, delay, callback, extra1, extra2)
  1474. {
  1475.    var _loc3_ = bright;
  1476.    var _loc2_ = 100 - Math.abs(_loc3_);
  1477.    var _loc1_ = 0;
  1478.    if(_loc3_ > 0)
  1479.    {
  1480.       _loc1_ = 256 * (_loc3_ / 100);
  1481.    }
  1482.    var destCt = {ra:_loc2_,rb:_loc1_,ga:_loc2_,gb:_loc1_,ba:_loc2_,bb:_loc1_};
  1483.    this.tween(["_ct_"],[destCt],seconds,animType,delay,callback,extra1,extra2);
  1484. };
  1485. ASSetPropFlags(Mp,"brightnessTo",1,0);
  1486. Mp.colorTo = function(destColor, seconds, animType, delay, callback, extra1, extra2)
  1487. {
  1488.    var _loc1_ = destColor;
  1489.    var _loc2_ = undefined;
  1490.    if(_loc1_ == undefined || _loc1_ == null)
  1491.    {
  1492.       _loc2_ = {rb:0,ra:100,gb:0,ga:100,bb:0,ba:100};
  1493.    }
  1494.    else
  1495.    {
  1496.       _loc2_ = {rb:_loc1_ >> 16,ra:0,gb:(_loc1_ & 65280) >> 8,ga:0,bb:_loc1_ & 255,ba:0};
  1497.    }
  1498.    this.tween(["_ct_"],[_loc2_],seconds,animType,delay,callback,extra1,extra2);
  1499. };
  1500. ASSetPropFlags(Mp,"colorTo",1,0);
  1501. Mp.colorTransformTo = function(ra, rb, ga, gb, ba, bb, aa, ab, seconds, animType, delay, callback, extra1, extra2)
  1502. {
  1503.    var _loc1_ = {ra:ra,rb:rb,ga:ga,gb:gb,ba:ba,bb:bb,aa:aa,ab:ab};
  1504.    this.tween(["_ct_"],[_loc1_],seconds,animType,delay,callback,extra1,extra2);
  1505. };
  1506. ASSetPropFlags(Mp,"colorTransformTo",1,0);
  1507. Mp.scaleTo = function(destScale, seconds, animType, delay, callback, extra1, extra2)
  1508. {
  1509.    this.tween(["_xscale","_yscale"],[destScale,destScale],seconds,animType,delay,callback,extra1,extra2);
  1510. };
  1511. ASSetPropFlags(Mp,"scaleTo",1,0);
  1512. Mp.slideTo = function(destX, destY, seconds, animType, delay, callback, extra1, extra2)
  1513. {
  1514.    this.tween(["_x","_y"],[destX,destY],seconds,animType,delay,callback,extra1,extra2);
  1515. };
  1516. ASSetPropFlags(Mp,"slideTo",1,0);
  1517. Mp.rotateTo = function(destRotation, seconds, animType, delay, callback, extra1, extra2)
  1518. {
  1519.    this.tween(["_rotation"],[destRotation],seconds,animType,delay,callback,extra1,extra2);
  1520. };
  1521. ASSetPropFlags(Mp,"rotateTo",1,0);
  1522. Mp.getFrame = function()
  1523. {
  1524.    return this._currentframe;
  1525. };
  1526. ASSetPropFlags(Mp,"getFrame",1,0);
  1527. Mp.setFrame = function(fr)
  1528. {
  1529.    this.gotoAndStop(Math.round(fr));
  1530. };
  1531. ASSetPropFlags(Mp,"setFrame",1,0);
  1532. Mp.addProperty("_frame",Mp.getFrame,Mp.setFrame);
  1533. ASSetPropFlags(Mp,"_frame",1,0);
  1534. Mp.frameTo = function(endframe, duration, animType, delay, callback, extra1, extra2)
  1535. {
  1536.    var _loc1_ = endframe;
  1537.    if(_loc1_ == undefined)
  1538.    {
  1539.       _loc1_ = this._totalframes;
  1540.    }
  1541.    this.tween("_frame",_loc1_,duration,animType,delay,callback,extra1,extra2);
  1542. };
  1543. ASSetPropFlags(Mp,"frameTo",1,0);
  1544. Mp.brightOffsetTo = function(percent, seconds, animType, delay, callback, extra1, extra2)
  1545. {
  1546.    var _loc1_ = 256 * (percent / 100);
  1547.    var _loc2_ = {ra:100,rb:_loc1_,ga:100,gb:_loc1_,ba:100,bb:_loc1_};
  1548.    this.tween(["_ct_"],[_loc2_],seconds,animType,delay,callback,extra1,extra2);
  1549. };
  1550. ASSetPropFlags(Mp,"brightOffsetTo",1,0);
  1551. Mp.contrastTo = function(percent, seconds, animType, delay, callback, extra1, extra2)
  1552. {
  1553.    var _loc1_ = {};
  1554.    _loc1_.ra = _loc1_.ga = _loc1_.ba = percent;
  1555.    _loc1_.rb = _loc1_.gb = _loc1_.bb = 128 - 1.28 * percent;
  1556.    this.tween(["_ct_"],[_loc1_],seconds,animType,delay,callback,extra1,extra2);
  1557. };
  1558. ASSetPropFlags(Mp,"contrastTo",1,0);
  1559. delete Mp;
  1560. _global.home = this;
  1561. invulLimit = 1.5;
  1562. invulLoop = 0;
  1563. invulLoopTime = 250;
  1564. invul;
  1565. points;
  1566. puValue = 150;
  1567. timeBonus = 25;
  1568. healthBonus = 200;
  1569. CumulativePoints = {level1:0,level2:0,level3:0,level4:0,level5:0,level6:0,puLevel1:0,puLevel2:0,puLevel3:0,puLevel4:0,puLevel5:0,puLevel6:0,collected:0};
  1570. respawn;
  1571. charHealth = 5;
  1572. charHits = 0;
  1573. totalLevels = 6;
  1574. TILE_W = 32;
  1575. TILE_H = 32;
  1576. orgX = 11.5;
  1577. orgY = 0;
  1578. enPts = 100;
  1579. ticks = 0;
  1580. if(fpsUpdater == undefined)
  1581. {
  1582.    fpsUpdater = setInterval(fpsInt,1000);
  1583. }
  1584. newGame = function()
  1585. {
  1586.    home.addGamePlay();
  1587.    CumulativePoints = {level1:0,level2:0,level3:0,level4:0,level5:0,level6:0,puLevel1:0,puLevel2:0,puLevel3:0,puLevel4:0,puLevel5:0,puLevel6:0,collected:0};
  1588.    home.attachMovie("hud_BKG","hud_BKG",99999);
  1589.    trace("New Game Started");
  1590.    home.mainMenu_mc.removeMovieClip();
  1591.    clearInterval(home.timeInt);
  1592.    home.charAlive = true;
  1593.    home.charHits = 0;
  1594.    home.itemsGrabbed = 0;
  1595.    home.totalPickups = 0;
  1596.    home.hud_BKG.points = 0;
  1597.    home.exit = false;
  1598.    ticks;
  1599.    currentLevel = 1;
  1600.    home.initTimer();
  1601.    starting = true;
  1602.    home.currentMap = home["Level" + home.currentLevel].currentMap;
  1603.    buildMap(home["Level" + home.currentLevel]["map" + home["Level" + home.currentLevel].currentMap]);
  1604. };
  1605. _global.delayItStart = function(time, func, timeName, objName, paramArg)
  1606. {
  1607.    timeName = new Timer();
  1608.    timeName.setDelay(1000);
  1609.    timeName.setAlarm(arguments[0]);
  1610.    objName = new Object();
  1611.    timeName.addListener(objName);
  1612.    objName.onTimerAlarm = function()
  1613.    {
  1614.       trace("Launching delayed function now: " + func + " " + time + " second delay");
  1615.       trace(paramArg);
  1616.       timeName.stop();
  1617.       delete objName;
  1618.       func.call(null,paramArg);
  1619.    };
  1620.    objName.onTimerTick = function()
  1621.    {
  1622.    };
  1623.    objName.onTimerStop = function()
  1624.    {
  1625.    };
  1626.    timeName.start();
  1627. };
  1628. mainMenu();
  1629. home._quality = "HIGH";
  1630.